import cloudbase from '../utils/cloudbase';
import userService from './userService';

// 本地存储键名常量
const USER_ID_STORAGE_KEY = 'monopoly_user_id';

/**
 * 游戏存档服务
 */
const saveGameService = {
  /**
   * 获取用户ID，优先从本地存储获取，如果没有则从服务获取并保存到本地存储
   * @returns {Promise<string>} 用户ID
   * @throws {Error} 如果用户未登录
   */
  async _getUserId() {
    try {
      // 优先从本地存储获取用户ID
      let userId = localStorage.getItem(USER_ID_STORAGE_KEY);
      console.log('_getUserId - 从本地存储获取的用户ID:', userId);
      
      // 如果本地存储中没有用户ID，则从服务获取
      if (!userId) {
        console.log('_getUserId - 本地存储中没有用户ID，尝试从服务获取');
        // 确保用户已登录
        await cloudbase.anonymousLogin();
        userId = await userService.getCurrentUserId();
        console.log('_getUserId - 从服务获取的用户ID:', userId);
        
        // 保存到本地存储
        if (userId) {
          console.log('_getUserId - 保存用户ID到本地存储:', userId);
          localStorage.setItem(USER_ID_STORAGE_KEY, userId);
        }
      }
      
      if (!userId) {
        console.error('_getUserId - 无法获取用户ID');
        throw new Error('用户未登录');
      }
      
      return userId;
    } catch (error) {
      console.error('_getUserId - 获取用户ID失败:', error);
      throw error;
    }
  },
  
  /**
   * 调用云函数
   * @param {string} action 操作类型
   * @param {Object} data 请求数据
   * @returns {Promise<Object>} 云函数返回结果
   * @throws {Error} 如果云函数调用失败
   */
  async _callCloudFunction(action, data) {
    try {
      // 确保用户已登录
      await cloudbase.anonymousLogin();
      
      // 确保数据中包含用户ID
      if (!data.userId) {
        const userId = await this._getUserId();
        data.userId = userId;
        console.log(`_callCloudFunction - 自动添加用户ID: ${userId}`);
      }
      
      console.log(`_callCloudFunction - 调用云函数 gameSave，action: ${action}, 参数:`, data);
      
      // 添加重试逻辑
      let retries = 3;
      let result;
      let lastError;
      
      while (retries > 0) {
        try {
          result = await cloudbase.callFunction({
            name: 'gameSave',
            data: { action, data }
          });
          break; // 成功则跳出循环
        } catch (err) {
          lastError = err;
          console.warn(`_callCloudFunction - 调用失败，剩余重试次数: ${retries - 1}`, err);
          retries--;
          if (retries > 0) {
            // 等待一段时间后重试
            await new Promise(resolve => setTimeout(resolve, 1000));
          }
        }
      }
      
      if (!result && lastError) {
        throw lastError;
      }
      
      console.log(`_callCloudFunction - 云函数返回结果:`, result);
      
      if (result.code !== 0) {
        console.error(`_callCloudFunction - 云函数调用失败，错误码: ${result.code}, 错误信息: ${result.msg}`);
        throw new Error(result.msg || `执行${action}操作失败`);
      }
      
      return result.data;
    } catch (error) {
      console.error(`_callCloudFunction - 调用云函数失败:`, error);
      throw error;
    }
  },

  /**
   * 保存游戏
   * @param {Object} saveData 存档数据
   * @param {String} saveId 存档ID（可选，更新时需要）
   * @param {String} gameName 存档名称（可选）
   * @returns {Promise<Object>} 保存结果，包含saveId
   */
  async saveGame(saveData, saveId = null, gameName = '自动存档') {
    try {
      console.log('saveGame - 开始保存游戏, saveId:', saveId, 'gameName:', gameName);
      const userId = await this._getUserId();
      console.log('saveGame - 获取到用户ID:', userId);
      
      // 确保存档名称不为空，并且优先使用传入的名称
      const finalGameName = gameName && gameName.trim() ? gameName.trim() : '我的存档';
      console.log('saveGame - 最终使用的存档名称:', finalGameName);
      
      // 直接调用云函数，绕过 _callCloudFunction 方法
      console.log('saveGame - 直接调用云函数 gameSave');
      const cloudbase = await import('../utils/cloudbase').then(m => m.default);
      
      // 准备请求参数 - 修复参数结构，确保gameName直接传递到云函数
      const requestData = {
        action: 'save',
        data: {
          userId,
          saveId,
          gameName: finalGameName, // 确保这个名称被正确使用
          gameData: saveData
        }
      };
      
      // 打印完整的请求参数，确保gameName正确传递
      console.log('saveGame - 发送到云函数的完整参数(JSON):', JSON.stringify(requestData));
      console.log('saveGame - 特别检查gameName:', requestData.data.gameName);
      
      console.log('saveGame - 发送到云函数的完整参数:', JSON.stringify(requestData));
      
      // 直接调用云函数
      const rawResult = await cloudbase.callFunction({
        name: 'gameSave',
        data: requestData
      });
      
      console.log('saveGame - 云函数原始返回结果:', rawResult);
      
      // 处理返回结果
      let resultData = {};
      
      if (rawResult && rawResult.code === 0 && rawResult.data) {
        resultData = rawResult.data;
      } else if (rawResult && rawResult.data) {
        resultData = rawResult.data;
      } else if (rawResult) {
        resultData = rawResult;
      }
      
      console.log('saveGame - 处理后的结果:', resultData);
      
      // 确保返回的数据包含saveId
      if (!resultData.saveId) {
        if (resultData._id) {
          resultData.saveId = resultData._id;
        } else {
          resultData.saveId = saveId;
        }
      }
      
      // 确保返回的数据包含gameName
      if (!resultData.gameName) {
        resultData.gameName = finalGameName;
      }
      
      console.log('saveGame - 最终返回结果:', resultData);
      
      // 强制刷新存档列表
      setTimeout(async () => {
        try {
          // 直接调用云函数获取最新存档列表
          const listResult = await cloudbase.callFunction({
            name: 'gameSave',
            data: { action: 'list', data: { userId } }
          });
          
          console.log('saveGame - 保存后直接获取存档列表结果:', listResult);
          
          // 处理返回结果
          let saves = [];
          if (Array.isArray(listResult)) {
            saves = listResult;
          } else if (listResult && Array.isArray(listResult.data)) {
            saves = listResult.data;
          } else if (listResult && listResult.code === 0 && Array.isArray(listResult.data)) {
            saves = listResult.data;
          }
          
          console.log('saveGame - 保存后刷新存档列表，数量:', saves.length);
        } catch (err) {
          console.error('saveGame - 保存后刷新存档列表失败:', err);
        }
      }, 2000);
      
      return resultData;
    } catch (error) {
      console.error('保存游戏失败:', error);
      throw error;
    }
  },

  /**
   * 加载游戏存档
   * @param {String} saveId 存档ID
   * @returns {Promise<Object>} 存档数据
   */
  async loadGame(saveId) {
    try {
      const userId = await this._getUserId();
      
      const result = await this._callCloudFunction('load', {
        userId,
        saveId
      });
      
      // 确保返回的是 gameData 字段的内容
      if (result && result.gameData) {
        return result.gameData;
      } else {
        throw new Error('游戏数据格式不正确');
      }
    } catch (error) {
      console.error('加载游戏存档失败:', error);
      throw error;
    }
  },

  /**
   * 删除游戏存档
   * @param {String} saveId 存档ID
   * @returns {Promise<Object>} 删除结果
   */
  async deleteGame(saveId) {
    try {
      const userId = await this._getUserId();
      
      return await this._callCloudFunction('delete', {
        userId,
        saveId
      });
    } catch (error) {
      console.error('删除游戏存档失败:', error);
      throw error;
    }
  },

  /**
   * 获取用户的所有游戏存档
   * @returns {Promise<Array>} 存档列表
   */
  async listSaves() {
    try {
      console.log('listSaves - 开始获取存档列表');
      const userId = await this._getUserId();
      console.log('listSaves - 获取到用户ID:', userId);
      
      // 直接调用云函数获取存档列表
      console.log('listSaves - 调用云函数 gameSave 获取存档列表');
      const cloudbase = await import('../utils/cloudbase').then(m => m.default);
      
      // 强制重新登录，确保用户ID正确
      await cloudbase.anonymousLogin();
      const freshUserId = await cloudbase.getUserId();
      console.log('listSaves - 重新登录后获取的用户ID:', freshUserId);
      
      // 使用最新的用户ID调用云函数
      const rawResult = await cloudbase.callFunction({
        name: 'gameSave',
        data: { action: 'list', data: { userId: freshUserId } }
      });
      
      console.log('listSaves - 云函数原始返回结果:', rawResult);
      
      // 处理返回结果，兼容不同的返回格式
      let result = [];
      
      if (rawResult && Array.isArray(rawResult)) {
        // 直接返回数组
        result = rawResult;
      } else if (rawResult && rawResult.code === 0 && rawResult.data) {
        // 包装在 code/data 结构中
        result = rawResult.data;
      } else if (rawResult && rawResult.data && !rawResult.code) {
        // 标准格式返回
        result = rawResult.data;
      } else if (rawResult && !Array.isArray(rawResult) && typeof rawResult === 'object') {
        // 可能是直接返回的对象，尝试转换为数组
        console.log('listSaves - 尝试将对象转换为数组');
        const keys = Object.keys(rawResult).filter(key => !isNaN(parseInt(key)));
        if (keys.length > 0) {
          result = keys.map(key => rawResult[key]);
          console.log('listSaves - 转换后的数组:', result);
        }
      }
      
      // 确保返回的是数组
      if (!Array.isArray(result)) {
        console.warn('listSaves - 处理后的结果不是数组:', result);
        result = [];
      }
      
      console.log('listSaves - 获取到存档列表，数量:', result.length);
      if (result.length > 0) {
        console.log('listSaves - 第一个存档信息:', {
          id: result[0]._id,
          name: result[0].gameName,
          userId: result[0].userId
        });
      } else {
        console.log('listSaves - 存档列表为空');
        
        // 尝试直接从数据库查询
        console.log('listSaves - 尝试直接查询数据库');
        try {
          const db = cloudbase.getDatabase();
          const collection = db.collection('gameSaves');
          const dbResult = await collection.where({
            userId: freshUserId
          }).orderBy('updateTime', 'desc').get();
          
          console.log('listSaves - 直接查询数据库结果:', dbResult);
          
          if (dbResult && dbResult.data && dbResult.data.length > 0) {
            result = dbResult.data;
            console.log('listSaves - 从数据库直接获取到存档列表，数量:', result.length);
          }
        } catch (dbError) {
          console.error('listSaves - 直接查询数据库失败:', dbError);
        }
      }
      
      // 最后的检查：如果仍然为空，尝试查询所有存档（不限制用户ID）
      if (result.length === 0) {
        console.log('listSaves - 尝试查询所有存档（不限制用户ID）');
        try {
          const db = cloudbase.getDatabase();
          const collection = db.collection('gameSaves');
          const allSavesResult = await collection.limit(10).get();
          
          console.log('listSaves - 查询所有存档结果:', allSavesResult);
          
          if (allSavesResult && allSavesResult.data && allSavesResult.data.length > 0) {
            console.log('listSaves - 数据库中存在存档，但可能与当前用户ID不匹配');
            console.log('listSaves - 第一个存档的用户ID:', allSavesResult.data[0].userId);
            console.log('listSaves - 当前用户ID:', freshUserId);
            
            // 如果发现存档的用户ID与当前用户ID不匹配，可能是用户ID获取有问题
            if (allSavesResult.data[0].userId !== freshUserId) {
              console.log('listSaves - 用户ID不匹配，尝试使用存档中的用户ID查询');
              const otherUserId = allSavesResult.data[0].userId;
              
              const matchingResult = await collection.where({
                userId: otherUserId
              }).get();
              
              if (matchingResult && matchingResult.data && matchingResult.data.length > 0) {
                result = matchingResult.data;
                console.log('listSaves - 使用存档中的用户ID查询成功，数量:', result.length);
                
                // 更新本地存储的用户ID
                localStorage.setItem('monopoly_user_id', otherUserId);
                console.log('listSaves - 更新本地存储的用户ID:', otherUserId);
              }
            }
          }
        } catch (allSavesError) {
          console.error('listSaves - 查询所有存档失败:', allSavesError);
        }
      }
      
      return result;
    } catch (error) {
      console.error('获取游戏存档列表失败:', error);
      return []; // 返回空数组而不是抛出错误，避免界面崩溃
    }
  },

  /**
   * 获取存档列表（别名方法，与 listSaves 功能相同）
   * @returns {Promise<Array>} 存档列表
   */
  async getSaves() {
    return this.listSaves();
  },
  
  /**
   * 删除存档（别名方法，与 deleteGame 功能相同）
   * @param {String} saveId 存档ID
   * @returns {Promise<Object>} 删除结果
   */
  async deleteSave(saveId) {
    return this.deleteGame(saveId);
  }
};

export default saveGameService;